home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 March / PCWorld_2007-03_cd.bin / v cisle / httrack / httrack-3.41-2.exe / {app} / src_win / WinHTTrack / newlang.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-15  |  21.9 KB  |  773 lines
  1.  
  2. // Win includes
  3. #include "stdafx.h"
  4. #include "Shell.h"
  5. #include <comdef.h>
  6.  
  7. // Hash for lang.h
  8. extern "C" {
  9.   #include "HTTrackInterface.h"
  10. #define HTS_INTERNAL_BYTECODE
  11.   #include "htsinthash.h"
  12. #undef HTS_INTERNAL_BYTECODE
  13. };
  14. #include "newlang.h"
  15.  
  16. // test
  17. #ifndef _MBCS
  18. #error "MBCS/DBCS support not found"
  19. #endif
  20. #include <locale.h>
  21.  
  22.  
  23. int NewLangStrSz=1024;
  24. inthash NewLangStr=NULL;
  25. int NewLangStrKeysSz=1024;
  26. inthash NewLangStrKeys=NULL;
  27. UINT NewLangCP = CP_THREAD_ACP;
  28. UINT NewLangFileCP = CP_THREAD_ACP;
  29.  
  30. typedef struct WinLangid {
  31.   int langId;
  32.   const char* name;
  33. } WinLangid;
  34.  
  35. WinLangid WINDOWS_LANGID[] = {
  36.   { 0x0436, "Afrikaans" },
  37.   { 0x041c, "Albanian" },
  38.   { 0x0401, "Arabic (Saudi Arabia)" },
  39.   { 0x0801, "Arabic (Iraq)" },
  40.   { 0x0c01, "Arabic (Egypt)" },
  41.   { 0x1001, "Arabic (Libya)" },
  42.   { 0x1401, "Arabic (Algeria)" },
  43.   { 0x1801, "Arabic (Morocco)" },
  44.   { 0x1c01, "Arabic (Tunisia)" },
  45.   { 0x2001, "Arabic (Oman)" },
  46.   { 0x2401, "Arabic (Yemen)" },
  47.   { 0x2801, "Arabic (Syria)" },
  48.   { 0x2c01, "Arabic (Jordan)" },
  49.   { 0x3001, "Arabic (Lebanon)" },
  50.   { 0x3401, "Arabic (Kuwait)" },
  51.   { 0x3801, "Arabic (U.A.E.)" },
  52.   { 0x3c01, "Arabic (Bahrain)" },
  53.   { 0x4001, "Arabic (Qatar)" },
  54.   { 0x042b, "Armenian" },
  55.   { 0x042c, "Azeri (Latin)" },
  56.   { 0x082c, "Azeri (Cyrillic)" },
  57.   { 0x042d, "Basque" },
  58.   { 0x0423, "Belarusian" },
  59.   { 0x0445, "Bengali (India)" },
  60.   { 0x141a, "Bosnian (Bosnia and Herzegovina)" },
  61.   { 0x0402, "Bulgarian" },
  62.   { 0x0455, "Burmese" },
  63.   { 0x0403, "Catalan" },
  64.   { 0x0404, "Chinese (Taiwan)" },
  65.   { 0x0804, "Chinese (PRC)" },
  66.   { 0x0c04, "Chinese (Hong Kong SAR, PRC)" },
  67.   { 0x1004, "Chinese (Singapore)" },
  68.   { 0x1404, "Chinese (Macao SAR)" },
  69.   { 0x041a, "Croatian" },
  70.   { 0x101a, "Croatian (Bosnia and Herzegovina)" },
  71.   { 0x0405, "Czech" },
  72.   { 0x0406, "Danish" },
  73.   { 0x0465, "Divehi" },
  74.   { 0x0413, "Dutch (Netherlands)" },
  75.   { 0x0813, "Dutch (Belgium)" },
  76.   { 0x0409, "English (United States)" },
  77.   { 0x0809, "English (United Kingdom)" },
  78.   { 0x0c09, "English (Australian)" },
  79.   { 0x1009, "English (Canadian)" },
  80.   { 0x1409, "English (New Zealand)" },
  81.   { 0x1809, "English (Ireland)" },
  82.   { 0x1c09, "English (South Africa)" },
  83.   { 0x2009, "English (Jamaica)" },
  84.   { 0x2409, "English (Caribbean)" },
  85.   { 0x2809, "English (Belize)" },
  86.   { 0x2c09, "English (Trinidad)" },
  87.   { 0x3009, "English (Zimbabwe)" },
  88.   { 0x3409, "English (Philippines)" },
  89.   { 0x0425, "Estonian" },
  90.   { 0x0438, "Faeroese" },
  91.   { 0x0429, "Farsi" },
  92.   { 0x040b, "Finnish" },
  93.   { 0x040c, "French (Standard)" },
  94.   { 0x080c, "French (Belgian)" },
  95.   { 0x0c0c, "French (Canadian)" },
  96.   { 0x100c, "French (Switzerland)" },
  97.   { 0x140c, "French (Luxembourg)" },
  98.   { 0x180c, "French (Monaco)" },
  99.   { 0x0456, "Galician" },
  100.   { 0x0437, "Georgian" },
  101.   { 0x0407, "German (Standard)" },
  102.   { 0x0807, "German (Switzerland)" },
  103.   { 0x0c07, "German (Austria)" },
  104.   { 0x1007, "German (Luxembourg)" },
  105.   { 0x1407, "German (Liechtenstein)" },
  106.   { 0x0408, "Greek" },
  107.   { 0x0447, "Gujarati" },
  108.   { 0x040d, "Hebrew" },
  109.   { 0x0439, "Hindi" },
  110.   { 0x040e, "Hungarian" },
  111.   { 0x040f, "Icelandic" },
  112.   { 0x0421, "Indonesian" },
  113.   { 0x0434, "isiXhosa/Xhosa (South Africa)" },
  114.   { 0x0435, "isiZulu/Zulu (South Africa)" },
  115.   { 0x0410, "Italian (Standard)" },
  116.   { 0x0810, "Italian (Switzerland)" },
  117.   { 0x0411, "Japanese" },
  118.   { 0x044b, "Kannada" },
  119.   { 0x0457, "Konkani" },
  120.   { 0x0412, "Korean" },
  121.   { 0x0812, "Korean (Johab)" },
  122.   { 0x0440, "Kyrgyz" },
  123.   { 0x0426, "Latvian" },
  124.   { 0x0427, "Lithuanian" },
  125.   { 0x0827, "Lithuanian (Classic)" },
  126.   { 0x042f, "FYRO Macedonian" },
  127.   { 0x043e, "Malay (Malaysian)" },
  128.   { 0x083e, "Malay (Brunei Darussalam)" },
  129.   { 0x044c, "Malayalam (India)" },
  130.   { 0x0481, "Maori (New Zealand)" },
  131.   { 0x043a, "Maltese (Malta)" },
  132.   { 0x044e, "Marathi" },
  133.   { 0x0450, "Mongolian" },
  134.   { 0x0414, "Norwegian (Bokmal)" },
  135.   { 0x0814, "Norwegian (Nynorsk)" },
  136.   { 0x0415, "Polish" },
  137.   { 0x0416, "Portuguese (Brazil)" },
  138.   { 0x0816, "Portuguese (Portugal)" },
  139.   { 0x0446, "Punjabi" },
  140.   { 0x046b, "Quechua (Bolivia)" },
  141.   { 0x086b, "Quechua (Ecuador)" },
  142.   { 0x0c6b, "Quechua (Peru)" },
  143.   { 0x0418, "Romanian" },
  144.   { 0x0419, "Russian" },
  145.   { 0x044f, "Sanskrit" },
  146.   { 0x043b, "Sami, Northern (Norway)" },
  147.   { 0x083b, "Sami, Northern (Sweden)" },
  148.   { 0x0c3b, "Sami, Northern (Finland)" },
  149.   { 0x103b, "Sami, Lule (Norway)" },
  150.   { 0x143b, "Sami, Lule (Sweden)" },
  151.   { 0x183b, "Sami, Southern (Norway)" },
  152.   { 0x1c3b, "Sami, Southern (Sweden)" },
  153.   { 0x203b, "Sami, Skolt (Finland)" },
  154.   { 0x243b, "Sami, Inari (Finland)" },
  155.   { 0x0c1a, "Serbian (Cyrillic)" },
  156.   { 0x1c1a, "Serbian (Cyrillic, Bosnia, and Herzegovina)" },
  157.   { 0x081a, "Serbian (Latin)" },
  158.   { 0x181a, "Serbian (Latin, Bosnia, and Herzegovina)" },
  159.   { 0x046c, "Sesotho sa Leboa/Northern Sotho (South Africa)" },
  160.   { 0x0432, "Setswana/Tswana (South Africa)" },
  161.   { 0x041b, "Slovak" },
  162.   { 0x0424, "Slovenian" },
  163.   { 0x040a, "Spanish (Spain, Traditional Sort)" },
  164.   { 0x080a, "Spanish (Mexican)" },
  165.   { 0x0c0a, "Spanish (Spain, Modern Sort)" },
  166.   { 0x100a, "Spanish (Guatemala)" },
  167.   { 0x140a, "Spanish (Costa Rica)" },
  168.   { 0x180a, "Spanish (Panama)" },
  169.   { 0x1c0a, "Spanish (Dominican Republic)" },
  170.   { 0x200a, "Spanish (Venezuela)" },
  171.   { 0x240a, "Spanish (Colombia)" },
  172.   { 0x280a, "Spanish (Peru)" },
  173.   { 0x2c0a, "Spanish (Argentina)" },
  174.   { 0x300a, "Spanish (Ecuador)" },
  175.   { 0x340a, "Spanish (Chile)" },
  176.   { 0x380a, "Spanish (Uruguay)" },
  177.   { 0x3c0a, "Spanish (Paraguay)" },
  178.   { 0x400a, "Spanish (Bolivia)" },
  179.   { 0x440a, "Spanish (El Salvador)" },
  180.   { 0x480a, "Spanish (Honduras)" },
  181.   { 0x4c0a, "Spanish (Nicaragua)" },
  182.   { 0x500a, "Spanish (Puerto Rico)" },
  183.   { 0x0430, "Sutu" },
  184.   { 0x0441, "Swahili (Kenya)" },
  185.   { 0x041d, "Swedish" },
  186.   { 0x081d, "Swedish (Finland)" },
  187.   { 0x045a, "Syriac" },
  188.   { 0x0449, "Tamil" },
  189.   { 0x0444, "Tatar (Tatarstan)" },
  190.   { 0x044a, "Telugu" },
  191.   { 0x041e, "Thai" },
  192.   { 0x041f, "Turkish" },
  193.   { 0x0422, "Ukrainian" },
  194.   { 0x0420, "Urdu (Pakistan)" },
  195.   { 0x0820, "Urdu (India)" },
  196.   { 0x0443, "Uzbek (Latin)" },
  197.   { 0x0843, "Uzbek (Cyrillic)" },
  198.   { 0x042a, "Vietnamese" },
  199.   { 0x0452, "Welsh (United Kingdom)" },
  200.   { 0, NULL }
  201. };
  202.  
  203. void LANG_LOAD(char* limit_to) {
  204.   CWaitCursor wait;
  205.   //
  206.   extern int NewLangStrSz;
  207.   extern inthash NewLangStr;
  208.   extern int NewLangStrKeysSz;
  209.   extern inthash NewLangStrKeys;
  210.   //
  211.   int selected_lang=LANG_T(-1);
  212.   //
  213.   if (!limit_to) {
  214.     LANG_DELETE();
  215.     NewLangStr=inthash_new(NewLangStrSz);
  216.     NewLangStrKeys=inthash_new(NewLangStrKeysSz);
  217.     if ((NewLangStr==NULL) || (NewLangStrKeys==NULL)) {
  218.       AfxMessageBox("Error in lang.h: not enough memory");
  219.     } else {
  220.       inthash_value_is_malloc(NewLangStr,1);
  221.       inthash_value_is_malloc(NewLangStrKeys,1);
  222.     }
  223.   }
  224.  
  225.   TCHAR ModulePath[MAX_PATH + 1];
  226.   ModulePath[0] = '\0';
  227.   ::GetModuleFileName(NULL, ModulePath, sizeof(ModulePath)/sizeof(TCHAR) - 1);
  228.   TCHAR* pos = _tcsrchr(ModulePath, '\\');
  229.   if (pos != NULL)
  230.   {
  231.     * ( pos + 1) = '\0';
  232.   } else {
  233.     ModulePath[0] = '\0';
  234.   }
  235.  
  236.   /* Load master file (list of keys and internal keys) */
  237.   CString app = ModulePath;
  238.   if (!limit_to) {
  239.     CString mname=app+"lang.def";
  240.     if (!fexist((char*)LPCTSTR(mname)))
  241.       mname="lang.def";
  242.     FILE* fp=fopen(mname,"rb");
  243.     if (fp) {
  244.       char intkey[8192];
  245.       char key[8192];
  246.       while(!feof(fp)) {
  247.         linput_cpp(fp,intkey,8000);
  248.         linput_cpp(fp,key,8000);
  249.         if (strnotempty(intkey) && strnotempty(key)) {
  250.           char* test=LANGINTKEY(key);
  251.  
  252.           /* Increment for multiple definitions */
  253.           if (strnotempty(test)) {
  254.             int increment=0;
  255.             size_t pos = strlen(key);
  256.             do {
  257.               increment++;
  258.               sprintf(key+pos,"%d",increment);
  259.               test=LANGINTKEY(key);
  260.             }  while (strnotempty(test));
  261.           }
  262.  
  263.           if (!strnotempty(test)) {         // Θviter doublons
  264.             // conv_printf(key,key);
  265.             size_t len;
  266.             char* buff;
  267.             len=strlen(intkey);
  268.             buff=(char*)malloc(len+2);
  269.             if (buff) {
  270.               strcpybuff(buff,intkey);
  271.               inthash_add(NewLangStrKeys,key,(intptr_t)buff);
  272.             }
  273.           }
  274.         } // if
  275.       }  // while
  276.       fclose(fp);
  277.     } else {
  278.       AfxMessageBox("FATAL ERROR\r\n'lang.def' file NOT FOUND!\r\nEnsure that the installation was complete!");
  279.       exit(0);
  280.     }
  281.   }
  282.   
  283.   /* Language Name? */
  284.   char* hashname;
  285.   {
  286.     char name[256];
  287.     sprintf(name,"LANGUAGE_%d",selected_lang+1);
  288.     hashname=LANGINTKEY(name);
  289.   }
  290.  
  291.   /* Get only language name */
  292.   if (limit_to) {
  293.     if (hashname)
  294.       strcpybuff(limit_to,hashname);
  295.     else
  296.       strcpybuff(limit_to,"???");
  297.     return;
  298.   }
  299.  
  300.   /* Error */
  301.   if (!hashname)
  302.     return;
  303.  
  304.   // xxc TEST
  305.   /*
  306.   setlocale( LC_ALL, "Japanese");
  307.   _setmbcp(932);    // shift-jis
  308.   setlocale( LC_ALL, ".932" );
  309.   setlocale( LC_ALL, "[.932]" );
  310.   CString st="";
  311.   int lid=SetThreadLocale(MAKELCID(MAKELANGID(LANG_JAPANESE,SUBLANG_NEUTRAL),SORT_DEFAULT ));
  312.   */
  313.  
  314.   /* Load specific language file */
  315.   {
  316.     int loops;
  317.     CString err_msg="";
  318.     // 2nd loop: load undefined strings
  319.     for(loops=0;loops<2;loops++) {
  320.       CString lbasename;
  321.       
  322.       {
  323.         char name[256];
  324.         sprintf(name,"LANGUAGE_%d",(loops==0)?(selected_lang+1):1);
  325.         hashname=LANGINTKEY(name);
  326.       }
  327.       lbasename.Format("lang/%s.txt",hashname);
  328.       CString lname=app+lbasename;
  329.       if (!fexist((char*)LPCTSTR(lname)))
  330.         lname=lbasename;
  331.       FILE* fp=fopen(lname,"rb");
  332.       if (fp) {
  333.         char extkey[8192];
  334.         TCHAR value[8192];
  335.         while(!feof(fp)) {
  336.           //int ssz;
  337.           linput_cpp(fp,extkey,8000);
  338.           linput_cpp(fp,value,8000);
  339.           /*
  340.           ssz=linput_cpp(fp,value,8000);
  341.           CString st=value;
  342.           AfxMessageBox(st);
  343.           if (ssz>0) {
  344.             int tst=0;
  345.             int test=IsTextUnicode(value,ssz,&tst);
  346.             unsigned short st2[1024];
  347.             int ret=MultiByteToWideChar(CP_UTF8,0,(char*)value,ssz,st2,1024);
  348.             if (ret>0) {
  349.               char st3[1024]="";
  350.               int ret2=WideCharToMultiByte(CP_THREAD_ACP,0,st2,ret,(char*)st3,1024,NULL,FALSE);
  351.               if (ret2>0) {
  352.                 AfxMessageBox(st3);
  353.               }
  354.             }
  355.           }
  356.           */
  357.  
  358.           if (strnotempty(extkey) && strnotempty(value)) {
  359.             int len;
  360.             char* buff;
  361.             char* intkey;
  362.             
  363.             intkey=LANGINTKEY(extkey);
  364.             
  365.             if (strnotempty(intkey)) {
  366.               
  367.               /* Increment for multiple definitions */
  368.               {
  369.                 char* test=LANGSEL(intkey);
  370.                 if (strnotempty(test)) {
  371.                   if (loops == 0) {
  372.                     int increment=0;
  373.                     size_t pos=strlen(extkey);
  374.                     do {
  375.                       increment++;
  376.                       sprintf(extkey+pos,"%d",increment);
  377.                       intkey=LANGINTKEY(extkey);
  378.                       if (strnotempty(intkey))
  379.                         test=LANGSEL(intkey);
  380.                       else
  381.                         test="";
  382.                     }  while (strnotempty(test));
  383.                   } else
  384.                     intkey="";
  385.                 } else {
  386.                   if (loops > 0) {
  387.                     err_msg += intkey;
  388.                     err_msg += " ";
  389.                   }
  390.                 }
  391.               }
  392.               
  393.               /* Add key */
  394.               if (strnotempty(intkey)) {
  395.                 len = (int) strlen(value);
  396.                 buff = (char*)malloc(len+2);
  397.                 if (buff) {
  398.                   conv_printf(value,buff);
  399.                   inthash_add(NewLangStr,intkey,(intptr_t)buff);
  400.                 }
  401.               }
  402.               
  403.             }
  404.           } // if
  405.         }  // while
  406.         fclose(fp);
  407.       } else {
  408.         AfxMessageBox("FATAL ERROR\r\n'lang.def' file NOT FOUND!\r\nEnsure that the installation was complete!");
  409.         exit(0);
  410.       }
  411.     }
  412.     if (err_msg.GetLength()>0) {
  413.       // AfxMessageBox("Error: undefined strings follows:\r\n"+err_msg);
  414.     }
  415.   }
  416.  
  417.  
  418.  
  419. #if 0
  420.   app=app+"lang.h";
  421.   if (!fexist((char*)LPCTSTR(app)))
  422.     app="lang.h";
  423.   
  424.   FILE* fp=fopen(app,"rb");
  425.   if (fp) {
  426.     char s[8192];
  427.     while(!feof(fp)) {
  428.       linput_cpp(fp,s,8000);
  429.       if (!strncmp(s,"#define ",8)) {
  430.         char* a;
  431.         char* name=s+8;
  432.         a=name;
  433.         while((*a!=' ') && (*a)) a++;
  434.         if ((*a) && (strlen(name)>0) && (((int) a - (int) name)<64)) {
  435.           *a++='\0';
  436.           if (limit_to) {
  437.             if (strcmp(name,limit_to))
  438.               a=NULL;
  439.           }
  440.           if (a) {
  441.             char* data;
  442.             data=a;
  443.             int toggle=0;
  444.             char* start_str=NULL;
  445.             int count=0;
  446.             while(*a) {
  447.               if (*a=='\"') {
  448.                 toggle++;
  449.                 if ((toggle%2)==1) {
  450.                   if (count==selected_lang) {
  451.                     start_str=a+1;
  452.                   }
  453.                   count++;
  454.                 } else {
  455.                   if (start_str) {
  456.                     char* buff;
  457.                     int len;
  458.                     len=(int) a - (int) start_str;
  459.                     if (len) {
  460.                       buff=(char*)malloc(len+2);
  461.                       if (buff) {
  462.                         int i=0,j=0;
  463.                         buff[0]='\0';
  464.                         //strncatbuff(buff,start_str,len);
  465.                         while(i<len) {
  466.                           switch(start_str[i]) {
  467.                           case '\\': 
  468.                             i++;
  469.                             switch(start_str[i]) {
  470.                             case 'a': buff[j]='\a'; break;
  471.                             case 'b': buff[j]='\b'; break;
  472.                             case 'f': buff[j]='\f'; break;
  473.                             case 'n': buff[j]='\n'; break;
  474.                             case 'r': buff[j]='\r'; break;
  475.                             case 't': buff[j]='\t'; break;
  476.                             case 'v': buff[j]='\v'; break;
  477.                             case '\'': buff[j]='\''; break;
  478.                             case '\"': buff[j]='\"'; break;
  479.                             case '\\': buff[j]='\\'; break;
  480.                             case '?': buff[j]='\?'; break;
  481.                             default: buff[j]=start_str[i]; break;
  482.                             }
  483.                             break;
  484.                             default: 
  485.                               buff[j]=start_str[i]; 
  486.                               break;
  487.                           }
  488.                           i++;
  489.                           j++;
  490.                         }
  491.                         buff[j++]='\0';
  492.                         if (!limit_to)
  493.                           inthash_add(NewLangStr,name,(intptr_t)buff);
  494.                         else {
  495.                           strcpybuff(limit_to,buff);
  496.                           free(buff);
  497.                           return;
  498.                         }
  499.                       }
  500.                     }
  501.                     start_str=NULL;
  502.                   }
  503.                 }
  504.               }
  505.               a++;
  506.             }
  507.           }
  508.           
  509.           //NewLangStr.SetAt(sname,st);
  510.           /*
  511.           } else {
  512.           CString info;
  513.           info.Format("Error in lang.h: %s",name);
  514.           AfxMessageBox(info);
  515.         */
  516.         }
  517.       }
  518.     }
  519.  
  520.  
  521.     fclose(fp);
  522.  
  523.   } else {
  524.     AfxMessageBox("FATAL ERROR\r\n'lang.h' file NOT FOUND!\r\nEnsure that the installation was complete!");
  525.     exit(0);
  526.   }
  527. #endif
  528.  
  529.   // Control limit_to
  530.   if (limit_to)
  531.     limit_to[0]='\0';
  532.  
  533.   // Set locale
  534.   if (!limit_to) {
  535.     CString charset = LANGUAGE_CHARSET;
  536.     charset.TrimLeft();
  537.     charset.TrimRight();
  538.     charset.MakeLower();
  539.     NewLangCP = CP_THREAD_ACP;
  540.     NewLangFileCP = CP_THREAD_ACP;
  541. #if 0
  542.     if (charset.GetLength() > 0) {
  543.       if (charset.Left(9) == "iso-8859-") {
  544.         int iso = 0;
  545.         int isoCP[] = {0, /* 0 */
  546.           1252, /* ISO-8859-1 */
  547.           1250, /* ISO-8859-2 */
  548.           0, /* ISO-8859-3 */
  549.           0, /* ISO-8859-4 */
  550.           1251, /* ISO-8859-5 */
  551.           1256, /* ISO-8859-6 */
  552.           1253, /* ISO-8859-7 */
  553.           1255, /* ISO-8859-8 */
  554.           1254, /* ISO-8859-9 */
  555.         };
  556.         if (sscanf(charset.GetBuffer(0) + 9, "%d", &iso) == 1) {
  557.           if (iso < sizeof(isoCP)/sizeof(isoCP[0])) {
  558.             if (isoCP[iso] != 0) {
  559.               NewLangFileCP = isoCP[iso];
  560.             }
  561.           }
  562.         }
  563.       } else if (charset.Left(8) == "windows-") {
  564.         int windows = 0;
  565.         if (sscanf(charset.GetBuffer(0) + 8, "%d", &windows) == 1) {
  566.           NewLangFileCP = windows;
  567.         }
  568.       } else if (charset == "shift-jis") {
  569.         NewLangFileCP = 932;
  570.       } else if (charset == "big5") {
  571.         NewLangFileCP = 950;
  572.       } else if (charset == "gb2312") {
  573.         NewLangFileCP = 936;
  574.       } else {
  575.         NewLangFileCP = CP_THREAD_ACP;
  576.       }
  577.     }
  578.     WORD acp = GetACP();
  579.     if (NewLangFileCP != CP_THREAD_ACP && NewLangFileCP != acp) {
  580.       char* currName = LANGUAGE_WINDOWSID;
  581.       LCID thl = GetThreadLocale();
  582.       WORD sid = SORTIDFROMLCID(thl);
  583.       WORD lid = 0;
  584.       WinLangid* lids;
  585.       if (currName[0]) {
  586.         for( lids = (WinLangid*)&WINDOWS_LANGID ; lids->name != NULL ; lids++ ) {
  587.           if (strcmp(currName, lids->name) == 0) {
  588.             lid = lids->langId;
  589.             break;
  590.           }
  591.         }
  592.         if (lid != 0) {
  593.           SetThreadLocale(MAKELCID(lid, sid));
  594.         }
  595.       }
  596.     }
  597. #endif
  598.  
  599.   }
  600.  
  601. }
  602.  
  603. void conv_printf(char* from,char* to) {
  604.   int i=0,j=0,len;
  605.   len = (int) strlen(from);
  606.   while(i<len) {
  607.     switch(from[i]) {
  608.     case '\\': 
  609.       i++;
  610.       switch(from[i]) {
  611.       case 'a': to[j]='\a'; break;
  612.       case 'b': to[j]='\b'; break;
  613.       case 'f': to[j]='\f'; break;
  614.       case 'n': to[j]='\n'; break;
  615.       case 'r': to[j]='\r'; break;
  616.       case 't': to[j]='\t'; break;
  617.       case 'v': to[j]='\v'; break;
  618.       case '\'': to[j]='\''; break;
  619.       case '\"': to[j]='\"'; break;
  620.       case '\\': to[j]='\\'; break;
  621.       case '?': to[j]='\?'; break;
  622.       default: to[j]=from[i]; break;
  623.       }
  624.       break;
  625.       default: 
  626.         to[j]=from[i]; 
  627.         break;
  628.     }
  629.     i++;
  630.     j++;
  631.   }
  632.   to[j++]='\0';
  633. }
  634.  
  635. void LANG_DELETE() {
  636.   extern int NewLangStrSz;
  637.   extern inthash NewLangStr;
  638.   extern int NewLangStrKeysSz;
  639.   extern inthash NewLangStrKeys;
  640.   //
  641.   inthash_delete(&NewLangStr);
  642.   inthash_delete(&NewLangStrKeys);
  643. }
  644.  
  645. // sΘlection de la langue
  646. void LANG_INIT() {
  647.   CWinApp* pApp = AfxGetApp();
  648.   if (pApp) {
  649.     int test = pApp->GetProfileInt("Language","IntId",0);
  650.     LANG_T(pApp->GetProfileInt("Language","IntId",0));
  651.   }
  652. }
  653.  
  654. int LANG_T(int l) {
  655.   if (l>=0) {
  656.     QLANG_T(l);
  657.     CWinApp* pApp = AfxGetApp();
  658.     if (pApp)
  659.       pApp->WriteProfileInt("Language","IntId",l);
  660.     LANG_LOAD(NULL);
  661.   }
  662.   return QLANG_T(-1);  // 0=default (english)
  663. }
  664.  
  665. int QLANG_T(int l) {
  666.   static int lng=0;
  667.   if (l>=0) {
  668.     lng=l;
  669.   }
  670.   return lng;  // 0=default (english)
  671. }
  672.  
  673.  
  674. /*
  675. char* LANGSEL(char* lang0,...) {
  676.   char* lang=lang0;
  677.   char* langalt="";
  678.   int langid=LANG_T(-1);
  679.   //
  680.   va_list argList;
  681.     va_start(argList, lang0);
  682.   while(langid>0) {
  683.     if (lang) {
  684.       if (strlen(langalt)==0) {
  685.         if (strlen(lang)>0)
  686.           langalt=lang;
  687.       }
  688.     }
  689.     langid--;
  690.     lang=va_arg(argList, char*);
  691.   }
  692.   va_end(argList);
  693.   //
  694.   if (!lang)
  695.     return langalt;
  696.   if (strlen(lang)==0)
  697.     return langalt;
  698.   return lang;
  699. }
  700. */
  701.  
  702. char* LANGSEL(char* name) {
  703.   intptr_t adr = 0;
  704.   if (NewLangStr)
  705.   if (!inthash_read(NewLangStr,name,&adr))
  706.     adr = NULL;
  707.   if (adr) {
  708.     return (char*)adr;
  709.   }
  710.   return "";
  711. }
  712.  
  713. char* LANGINTKEY(char* name) {
  714.   intptr_t adr = 0;
  715.   if (NewLangStrKeys)
  716.   if (!inthash_read(NewLangStrKeys,name,&adr))
  717.     adr=NULL;
  718.   if (adr) {
  719.     return (char*)adr;
  720.   }
  721.   return "";
  722. }
  723.  
  724. static _bstr_t ConvertCodepage(LPCSTR str, UINT codePage)
  725. {
  726.   _bstr_t returnValue;
  727.   BOOL ok = TRUE;
  728.   int mbLength = (int) strlen(str);
  729.   int wideLength = ::MultiByteToWideChar( codePage, 0, str, mbLength, NULL, NULL); 
  730.   if (wideLength > 0) 
  731.   {
  732.     wchar_t *wcharBuffer = new wchar_t[wideLength+1]; 
  733.     ::MultiByteToWideChar( codePage, 0, str, mbLength, wcharBuffer, wideLength); 
  734.     wcharBuffer[wideLength] = '\0';
  735.     returnValue = wcharBuffer;
  736.     delete wcharBuffer;
  737.   }
  738.   return returnValue;
  739. }
  740.  
  741. BOOL SetDlgItemTextCP(HWND hDlg, int nIDDlgItem, LPCSTR lpString) {
  742.   if (NewLangCP != CP_THREAD_ACP)
  743.     return SetDlgItemTextW(hDlg, nIDDlgItem, ConvertCodepage(lpString, NewLangCP));
  744.   else
  745.     return SetDlgItemTextA(hDlg, nIDDlgItem, lpString);
  746. }
  747.  
  748. BOOL SetDlgItemTextCP(CWnd* wnd, int nIDDlgItem, LPCSTR lpString) {
  749.   return SetDlgItemTextCP(wnd->m_hWnd, nIDDlgItem, lpString);
  750. }
  751.  
  752. BOOL SetWindowTextCP(HWND hWnd, LPCSTR lpString) {
  753.   if (NewLangCP != CP_THREAD_ACP)
  754.     return SetWindowTextW(hWnd, ConvertCodepage(lpString, NewLangCP));
  755.   else
  756.     return SetWindowTextA(hWnd, lpString);
  757. }
  758.  
  759. BOOL SetWindowTextCP(CWnd* wnd, LPCSTR lpString) {
  760.   return SetWindowTextCP(wnd->m_hWnd, lpString);
  761. }
  762.  
  763. BOOL ModifyMenuCP(HMENU hMnu, UINT uPosition, UINT uFlags, UINT uIDNewItem, LPCSTR lpNewItem) {
  764.   if (NewLangCP != CP_THREAD_ACP)
  765.     return ModifyMenuW(hMnu, uPosition, uFlags, uIDNewItem, ConvertCodepage(lpNewItem, NewLangCP));
  766.   else
  767.     return ModifyMenuA(hMnu, uPosition, uFlags, uIDNewItem, lpNewItem);
  768. }
  769.  
  770. BOOL ModifyMenuCP(CMenu* menu, UINT uPosition, UINT uFlags, UINT uIDNewItem, LPCSTR lpNewItem) {
  771.   return ModifyMenuCP(menu->m_hMenu, uPosition, uFlags, uIDNewItem, lpNewItem);
  772. }
  773.